Summary

Add the TracingChannel "early-exit when no subscribers" optimization, matching native Node.js >= 22 / >= 20.13 behavior introduced in nodejs/node#51915. This was a known TODO in checks.js (now removed).

When no channel has subscribers, traceSync / tracePromise / traceCallback skip publishing entirely and invoke fn directly. Per native semantics, this intentionally bypasses traceCallback's callback validation and tracePromise's thenable coercion — both match Node 22+ exactly.

Applied in two places:

• patch-tracing-channel.js — full polyfill, used on Node < 18.19
• patch-tracing-channel-has-subscribers.js — wraps native TC's three trace methods, used on Node 18.19–20.12

Implementation notes

The wrapper for the native path uses arity-specialized branches (3–7 arg fast paths) and dispatches via a tamper-resistant Function.prototype.call.bind(Function.prototype.call) primordial. This:

• Avoids rest-parameter array allocation and [fn, context, thisArg, ...args] re-spread allocation on the slow path.
• Stays correct when user code does f.call = null or Function.prototype.call = null (native trace*() doesn't crash on these — neither should the polyfill).

The polyfill's hasSubscribers getter is null-safe so partial object-form tracingChannel({start, end, error}) construction (which the polyfill has always accepted leniently, unlike native) can still probe tc.hasSubscribers without crashing on missing async channels.

Benchmark — Node 20.12.2 (has-subscribers patch path, the primary target)

This is the path used in production on Node 18.19–20.12, where native TC exists but lacks early-exit. Median of 3 runs.

No subscribers — early-exit fires (the hot fast path)

(The sub-6 ns/op numbers reflect V8 fully inlining through the early-exit at the benchmark site — the upper bound. Real-world wins are bounded by the baseline column: ~25–290 ns of native trace work eliminated per call.)

With subscribers — slow path runs

The arity-specialized wrapper kept the slow-path regression small (4–29 ns vs ~30–60 ns with a naive (fn, context, thisArg, ...args) rest-spread wrapper).

Benchmark — Node 20.12.2 (full polyfill path, Node < 18.19, legacy)

No subscribers (early-exit fires)

The polyfill traceSync regression is a V8 inlining artifact: V8 fully inlines the polyfill's empty JS publish() no-op into nothing, so the baseline appears very fast. The early-exit check defeats that inlining. This codepath is only reached on Node < 18.19 (legacy), and the absolute overhead is ~100 ns.

With subscribers (slow path)

All three methods within ~1–12% of baseline (noise).

Test plan

• Existing tests pass on Node 24.15.0 and Node 20.12.2 (./test.sh)
• Lint clean (npm run lint)
• CI matrix green on all 43 jobs (Node 12.17 → 23.x) — will re-run after push
• Renamed pre-existing test-diagnostics-channel-tracing-channel-sync-early-exit.js → .spec.js so it actually runs (test.sh globs *.spec.js); fixed a tape t.plan(0) issue with explicit t.end()
• Added matching tests for tracePromise and traceCallback early-exit
• Added regression test for fn.call = null poisoning (Reflect.apply / primordial dispatch)
• Added regression test for partial object-form tracingChannel({start, end, error}) on the polyfill path

🤖 Generated with Claude Code